package com.pm.buglist.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pm.buglist.domain.ExceptionCode;
import com.pm.buglist.mapper.ExceptionCodeMapper;
import com.pm.buglist.service.ExceptionCodeService;
import com.pm.common.core.redis.RedisCache;
import com.pm.common.utils.SecurityUtils;
import com.github.yitter.idgen.YitIdHelper;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.List;

/**
 * <p>
 * 异常代码管理表 服务实现类
 * </p>
 *
 * @author wwm
 * @since 2023-12-14
 */
@Service
public class ExceptionCodeServiceImpl extends ServiceImpl<ExceptionCodeMapper, ExceptionCode> implements ExceptionCodeService {

    @Resource
    private ExceptionCodeMapper exceptionCodeMapper;

    @Resource
    private RedisCache redisCache;

    private final String RedisKey="EX_CODE";

    /**
     * 查询异常代码管理
     *
     * @param id 异常代码管理主键
     * @return 异常代码管理
     */
    @Override
    public ExceptionCode selectExceptionCodeById(Long id)
    {
        return exceptionCodeMapper.selectExceptionCodeById(id);
    }

    /**
     * 查询异常代码管理列表
     *
     * @param exceptionCode 异常代码管理
     * @return 异常代码管理
     */
    @Override
    public List<ExceptionCode> selectExceptionCodeList(ExceptionCode exceptionCode)
    {
        return exceptionCodeMapper.selectExceptionCodeList(exceptionCode);
    }

    /**
     * 新增异常代码管理
     *
     * @param exceptionCode 异常代码管理
     * @return 结果
     */
    @Override
    public int insertExceptionCode(ExceptionCode exceptionCode)
    {
        Integer integer = checkExceptionOnly(exceptionCode.getCode(), exceptionCode.getType());
        if(integer>0){
            throw new RuntimeException("类型已存在！");
        }
        Long userId = SecurityUtils.getUserId();
        exceptionCode.setCreateUser(userId);
        exceptionCode.setId(YitIdHelper.nextId());
        exceptionCode.setCreateTime(LocalDateTime.now());
        int i = exceptionCodeMapper.insertExceptionCode(exceptionCode);
        if(i>0){
            try {
                redisCache.deleteObject(RedisKey);
            } catch (Exception e) {
                e.printStackTrace();
                log.error("插入异常代码成功，但删除缓存失败");
            }
        }
        return i;
    }

    /**
     * 修改异常代码管理
     *
     * @param exceptionCode 异常代码管理
     * @return 结果
     */
    @Override
    public int updateExceptionCode(ExceptionCode exceptionCode)
    {
        //验证异常代码/类型是否已存在
        QueryWrapper<ExceptionCode> wrapper = new QueryWrapper<>();
//        if(!StringUtils.isEmpty(exceptionCode.getCode())){
//            boolean only=true;
//            wrapper.eq("code",exceptionCode.getCode()).eq("del_flag",'0');
//            ExceptionCode exceptionCode1 = baseMapper.selectOne(wrapper);
//            if(!ObjectUtils.isEmpty(exceptionCode1)){
//                if(!exceptionCode.getId().equals(exceptionCode1.getId())){
//                    only=false;
//                }
//            }
//            if(!only){
//                throw new RuntimeException("异常代码已存在！");
//            }
//        }
//        wrapper.clear();
        if(!StringUtils.isEmpty(exceptionCode.getType())){
            boolean only=true;
            wrapper.eq("type",exceptionCode.getType()).eq("code",exceptionCode.getCode()).eq("del_flag",'0');
            ExceptionCode exceptionCode1 = baseMapper.selectOne(wrapper);
            if(!ObjectUtils.isEmpty(exceptionCode1)){
                if(!exceptionCode.getId().equals(exceptionCode1.getId())){
                    only=false;
                }
            }
            if(!only){
                throw new RuntimeException("类型已存在！");
            }
        }
        Long userId = SecurityUtils.getUserId();
        exceptionCode.setUpdateUser(userId);
        exceptionCode.setUpdateTime(LocalDateTime.now());
        int i = exceptionCodeMapper.updateExceptionCode(exceptionCode);
        if(i>0){
            try {
                redisCache.deleteObject(RedisKey);
            } catch (Exception e) {
                e.printStackTrace();
                log.error("更新异常代码成功，但删除缓存失败");
            }
        }
        return i;
    }

    /**
     * 批量删除异常代码管理(逻辑删除)
     *
     * @param ids 需要删除的异常代码管理主键
     * @return 结果
     */
    @Override
    public int deleteExceptionCodeByIds(Long[] ids)
    {
        Long userId = SecurityUtils.getUserId();
        for (Long id : ids) {
            exceptionCodeMapper.updateDelete(id,userId);
        }
        try {
            redisCache.deleteObject(RedisKey);
        } catch (Exception e) {
            e.printStackTrace();
            log.error("删除异常代码成功，但删除缓存失败");
        }
        return 1;
//        return exceptionCodeMapper.deleteExceptionCodeByIds(ids);
    }

    //验证异常代码与类型是否存在
    private Integer checkExceptionOnly(String code,String type){
        QueryWrapper<ExceptionCode> wrapper = new QueryWrapper<>();
        if(!StringUtils.isEmpty(code)){
            wrapper.eq("code",code);
        }
        if(!StringUtils.isEmpty(code)&&!StringUtils.isEmpty(type)){
            wrapper.eq("type",type);
        }
        if(StringUtils.isEmpty(code)&&!StringUtils.isEmpty(type)){
            wrapper.eq("type",type);
        }
        wrapper.eq("del_flag",'0');
        Integer integer = baseMapper.selectCount(wrapper);
        return integer;
    }

}
